package com.jy.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.jy.common.enums.ResponseWrapper;
import com.jy.common.model.good.param.AddCartParam;
import com.jy.common.model.good.param.AddSearchGoodsHistoryParam;
import com.jy.common.model.good.result.GetGoodsEvaluatesResult;
import com.jy.common.tool.CommonTool;
import com.jy.common.tool.ToolForDateTime;
import com.jy.entity.*;
import com.jy.mapper.*;
import com.jy.service.GoodsService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * <p>
 * 商品表 服务实现类
 * </p>
 *
 * @author fzg
 * @since 2024-11-14
 */
@Service
public class GoodsServiceImpl extends ServiceImpl<GoodsMapper, Goods> implements GoodsService {

    private final GoodsMapper goodsMapper;

    private final GoodsStyleMapper goodsStyleMapper;

    private final UserEvaluateGoodsMapper userEvaluateGoodsMapper;

    private final CollectMapper collectMapper;

    private final CartMapper cartMapper;

    private final ChatMessagesMapper chatMessagesMapper;

    private final CartGoodsMapper cartGoodsMapper;

    private final SearchHistoryMapper searchHistoryMapper;

    private final UserMapper userMapper;

    public GoodsServiceImpl(GoodsMapper goodsMapper, GoodsStyleMapper goodsStyleMapper, UserEvaluateGoodsMapper userEvaluateGoodsMapper, CollectMapper collectMapper, CartMapper cartMapper, ChatMessagesMapper chatMessagesMapper, CartGoodsMapper cartGoodsMapper, SearchHistoryMapper searchHistoryMapper, UserMapper userMapper) {
        this.goodsMapper = goodsMapper;
        this.goodsStyleMapper = goodsStyleMapper;
        this.userEvaluateGoodsMapper = userEvaluateGoodsMapper;
        this.collectMapper = collectMapper;
        this.cartMapper = cartMapper;
        this.chatMessagesMapper = chatMessagesMapper;
        this.cartGoodsMapper = cartGoodsMapper;
        this.searchHistoryMapper = searchHistoryMapper;
        this.userMapper = userMapper;
    }

    @Override
    public ResponseWrapper getGoodsIndexRecommendInfo(String type) {

        System.out.println("类型：" + type);

        // 定义返回结果
        HashMap<String, Object> result = new HashMap<>();

        // 获取新品3件
        List<Goods> goods = goodsMapper.selectList(new LambdaQueryWrapper<Goods>()
                .eq(Goods::getGoodsBelong,type)
                .eq(Goods::getIsNew,true)
                .orderByDesc(Goods::getCreateTime)
                .last("limit 3")
        );

        // 返回新品
        ArrayList<HashMap<String, Object>> newGoods = new ArrayList<>();
        goods.forEach(g -> {
            HashMap<String, Object> map = new HashMap<>();
            map.put("goodAid",g.getAid());
            map.put("newGoodImage",g.getGoodsMainImage());
            map.put("newGoodTitle",g.getGoodsName());
            map.put("newGoodDesc",g.getGoodsDesc().length() > 16 ? g.getGoodsDesc().substring(0,16) + "..." : g.getGoodsDesc());
            newGoods.add(map);
        });
        result.put("newGoods", newGoods);

        // 返回热卖商品
        List<Goods> hotGoods = goodsMapper.selectList(new LambdaQueryWrapper<Goods>()
                .eq(Goods::getGoodsBelong,type)
                .eq(Goods::getIsHot,true)
                .orderByDesc(Goods::getPurchaseQuantity)
                .last("limit 5")
        );
        ArrayList<HashMap<String, Object>> hotGoodsResult = new ArrayList<>();
        hotGoods.forEach(g -> {
            HashMap<String, Object> map = new HashMap<>();
            map.put("goodAid",g.getAid());
            map.put("hotSellImage",g.getGoodsMainImage());
            String goodsLabel = g.getGoodsLabel();
            map.put("desc",g.getGoodsLabel().contains(";") ? g.getGoodsLabel().split(";")[0] : g.getGoodsLabel());
            map.put("hotSellTitle",g.getGoodsName());
            map.put("price","¥ " + g.getGoodsPrice());
            hotGoodsResult.add(map);
        });
        result.put("hotSellRecommendGoods", hotGoodsResult);

        // 返回为你推荐
        List<Goods> goods1 = goodsMapper.selectList(new LambdaQueryWrapper<Goods>()
                .eq(Goods::getGoodsBelong,type)
                .orderByDesc(Goods::getCreateTime)
                .orderByDesc(Goods::getPurchaseQuantity)
                .last("limit 3,9")
        );
        ArrayList<HashMap<String, Object>> foryouRecommendGoods = new ArrayList<>();
        goods1.forEach(g -> {
            HashMap<String, Object> map = new HashMap<>();
            map.put("goodAid",g.getAid());
            map.put("imgSrc",g.getGoodsMainImage());
            map.put("desc",g.getGoodsLabel().contains(";") ? g.getGoodsLabel().split(";")[0] : g.getGoodsLabel());
            map.put("goodTitle",g.getGoodsName());
            map.put("price","¥ " + g.getGoodsPrice());
            foryouRecommendGoods.add(map);
        });
        result.put("foryouRecommendGoods", foryouRecommendGoods);

        // 推荐的全部商品（除开上面已经查询出来的）
        List<Goods> goods2 = goodsMapper.selectList(new LambdaQueryWrapper<Goods>()
                .eq(Goods::getGoodsBelong, type)
                .orderByDesc(Goods::getUpdateTime)
                .orderByDesc(Goods::getPurchaseQuantity)
                .last("LIMIT 10, 20")
        );
        ArrayList<HashMap<String, Object>> allGoods = new ArrayList<>();
        for (Goods goods3 : goods2) {
            HashMap<String, Object> map = new HashMap<>();
            map.put("goodsAid",goods3.getAid());
            map.put("goodsName",goods3.getGoodsName());
            map.put("img",goods3.getGoodsMainImage());
            map.put("price","￥" + goods3.getGoodsPrice());
            allGoods.add(map);
        }
        result.put("allGoods",allGoods);

        return ResponseWrapper.markSuccess(result);
    }

    @Override
    public ResponseWrapper getGoodsDetailInfo(Integer currentUserAid, Long goodAid) {

        // 获取商品（
        // 轮播展示图，
        // 商品名称，
        // 商品标签，
        // 价格，
        // 兑换积分，
        // 库存，
        // 商品页面最下端的详细图，
        // 商品的全部评价，
        // 当前登录用户是否收藏了该商品
        // 当前用户购物车内商品数量
        // 当前登录用户未读消息
        // ）
        HashMap<String, Object> result = new HashMap<>();
        // 获取轮播图
        Goods goods = goodsMapper.selectById(goodAid);
        String goodsSwipers = goods.getGoodsSwipers();
        String[] swiperArr = goodsSwipers.split(";");
        result.put("swiperList", swiperArr);

        // 获取其他
        HashMap<String, Object> goodInfo = new HashMap<>();
        goodInfo.put("goodAid",goodAid);
        goodInfo.put("goodCode",goods.getGoodsCode());
        goodInfo.put("goodTitle",goods.getGoodsName());
        String goodsLabel = goods.getGoodsLabel();
        String[] goodLabels = goodsLabel.split(";");
        goodInfo.put("goodLabels",goodLabels);
        goodInfo.put("goodPrice","¥" + goods.getGoodsPrice().toString());
        goodInfo.put("needPoints",goods.getGoodsRecords());
        goodInfo.put("stockNum",goods.getGoodsStock());

        // 当前用户选择的款式(共多少款可以选择)
        List<GoodsStyle> goodsStyles = goodsStyleMapper.selectList(new LambdaQueryWrapper<GoodsStyle>()
                .eq(GoodsStyle::getGoodAid, goodAid)
        );
        if (!goodsStyles.isEmpty()) {
            goodInfo.put("selectedStyle","共有" + goodsStyles.size() + "款可选择");
        }else {
            // 如果没有款式，那就是说只有这一款，只选择数量即可
            goodInfo.put("selectedStyle","数量 X 1");
        }

        // 查询该商品的用户评价
        List<GetGoodsEvaluatesResult> goodsEvaluates = userEvaluateGoodsMapper.getGoodsEvaluates(goodAid);
        // 调整发布时间格式和评价图片
        String[] s = new String[0];
        goodsEvaluates.forEach(g -> {
            g.setReviewReleaseTime(ToolForDateTime.LocalDateTimeToStringToDate(g.getCreateTime()));
            if(g.getEvaluateImgs() != null){
                g.setShareImages(g.getEvaluateImgs().split(";"));
            }else {
                g.setShareImages(s);
            }
        });
        goodInfo.put("userReviewNum",goodsEvaluates.size());
        goodInfo.put("userReviews",goodsEvaluates);

        // 商品的详细图片
        goodInfo.put("goodDetailInfoImages", goods.getGoodsDetailImages().split(";"));
        result.put("goodInfo",goodInfo);
        // 获取该商品的所有款式信息
        HashMap<String, Object> goodStyle = new HashMap<>();
        goodStyle.put("showPhoto",goods.getGoodsMainImage());

        //  数据返回格式：styles: [
        //                      {
        //							styleName: '颜色选择',
        //							styleItens: ['白色', '棕色', '黑色']
        //						},
        //						{
        //							styleName: '重量选择',
        //							styleItens: ['210g', '250g']
        //						}
        //					],
        // System.out.println("款式在这里");
        // System.out.println(CommonTool.convertToFrontendFormat(goodsStyles));
        List<Map<String, Object>> stylesMaps = CommonTool.convertToFrontendFormat(goodsStyles);
//        System.out.println("款式map");
//        System.out.println(stylesMaps);
        goodStyle.put("styles",CommonTool.convertToFrontendFormat(goodsStyles));
        // 没选款式的时候价格就是默认第一个款式的价格
        goodStyle.put("goodPrice", goodsStyles.isEmpty() ? 0 : "¥" + goodsStyles.get(0).getPrice());
        goodStyle.put("records",goodsStyles.isEmpty() ? 0 : goodsStyles.get(0).getRecords());
        goodStyle.put("goodName",goods.getGoodsName());
        String styleValue = goodsStyles.isEmpty() ? "" : goodsStyles.get(0).getStyleValue();
        if (styleValue.isEmpty()){
            goodStyle.put("goodSelectStyle","");
        } else if (styleValue.contains(",")) {
            goodStyle.put("goodSelectStyle",styleValue.replace(","," "));
        } else {
            goodStyle.put("goodSelectStyle",styleValue);
        }
        goodStyle.put("xiangouNum", goodsStyles.isEmpty() ? 0 : goodsStyles.get(0).getStyleStock());
        goodStyle.put("buyNumber",1);
        result.put("goodStyle",goodStyle);
        // 查询当前登录用户是否收藏该商品
        List<Collect> goodCollectList = collectMapper.selectList(new LambdaQueryWrapper<Collect>()
                .eq(Collect::getCollectAid, goodAid)
                .eq(Collect::getCollectType, "商品")
                .eq(Collect::getUserAid, currentUserAid)
        );
        result.put("isCollect", !goodCollectList.isEmpty());

        if(goodCollectList.isEmpty()){
            result.put("collectText","收藏");
            result.put("heartType","heart");
            result.put("heartColor","#666666");
        }else {
            result.put("collectText","已收藏");
            result.put("heartType","heart-filled");
            result.put("heartColor","#ff1c1c");
        }

        // 查询当前登录的用户购物车商品数量
        Cart cart = cartMapper.selectOne(new LambdaQueryWrapper<Cart>()
                .eq(Cart::getIsEmpty, false)
                .eq(Cart::getUserAid, currentUserAid)
        );
        result.put("currentLoginUserCartGoodsNum",cart == null ? 0 : cart.getGoodsNum());

        // 当前登录用户未读消息
        List<ChatMessages> chatMessages = chatMessagesMapper.selectList(new LambdaQueryWrapper<ChatMessages>()
                .eq(ChatMessages::getSenderId, currentUserAid)
                .eq(ChatMessages::getProductId, goodAid)
                .eq(ChatMessages::getIsRead, false)
        );
        System.out.println("未读消息：" + chatMessages.size());
        result.put("productUnreadMessageNum",chatMessages.isEmpty() ? 0 : chatMessages.size());

        return ResponseWrapper.markSuccess(result);
    }

    @Override
    public ResponseWrapper getThisStyleInfoApi(String style, Integer goodAid) {
        HashMap<String, Object> result = new HashMap<>();
//        System.out.println(style);
        String replace = style.replace(" ", ",");
//        System.out.println(replace);
        GoodsStyle goodsStyle = goodsStyleMapper.selectOne(new LambdaQueryWrapper<GoodsStyle>()
                .eq(GoodsStyle::getGoodAid, goodAid)
                .eq(GoodsStyle::getStyleValue, replace)
        );
        if (goodsStyle != null) {
            result.put("goodStyleAid",goodsStyle.getAid().toString());
            result.put("showPhoto",goodsStyle.getStyleImage());
            result.put("goodPrice","¥" + goodsStyle.getPrice().toString());
            result.put("records",goodsStyle.getRecords());
            result.put("xiangouNum",goodsStyle.getStyleStock());
        }
        return ResponseWrapper.markSuccess(result);
    }

    @Override
    public ResponseWrapper cancelCollectGoods(Integer userAidByToken, Integer goodAid) {

        int delete = collectMapper.delete(new LambdaQueryWrapper<Collect>()
                .eq(Collect::getUserAid, userAidByToken)
                .eq(Collect::getCollectAid, goodAid)
        );

        // user表的collect_num字段-1
        User user = userMapper.selectById(userAidByToken);
        user.setCollectNum(user.getCollectNum().equals(0) ? 0 : user.getCollectNum() - 1);
        userMapper.updateById(user);

        return delete > 0? ResponseWrapper.markSuccess() : ResponseWrapper.markError();
    }

    @Override
    public ResponseWrapper collectGoods(Integer userAidByToken, Integer goodAid) {

        int goodCollect = collectMapper.insert(new Collect() {{
            setCollectAid(Long.valueOf(goodAid));
            setCollectType("商品");
            setUserAid(userAidByToken.longValue());
        }});

        // user表的collect_num字段值+1
        User user = userMapper.selectById(userAidByToken);
        user.setCollectNum(user.getCollectNum() + 1);
        userMapper.updateById(user);
        return goodCollect > 0? ResponseWrapper.markSuccess() : ResponseWrapper.markError();
    }

    @Override
    public ResponseWrapper addCartApi(Integer userAidByToken, AddCartParam param) {

//        Integer goodsStyleAid = param.getGoodsStyleAid();
//        Integer styleCount = param.getStyleCount();
//
//        Long goodStyleAid = Long.valueOf(goodsStyleAid.toString());
//        // 先查询该用户是否存在购物车
//        Cart cart = cartMapper.selectOne(new LambdaQueryWrapper<Cart>()
//                .eq(Cart::getUserAid, userAidByToken)
//        );
//
//        // 如果前端传过来的样式aid为0，说明该商品没有样式
//        if(param.getGoodsStyleAid().equals(0)){
//            if (cart != null) {
//                CartGoods cartGoods = cartGoodsMapper.selectOne(new LambdaQueryWrapper<CartGoods>()
//                        .eq(CartGoods::getCartAid, cart.getAid())
//                        .eq(CartGoods::getGoodsAid, param.getGoodAid())
//                        .eq(CartGoods::getGoodsStyleAid, goodsStyleAid)
//                );
//                if(cartGoods != null){
//                    cartGoods.setCount(cartGoods.getCount() + styleCount);
//                    cartGoodsMapper.updateById(cartGoods);
//                }else {
//                    CartGoods cartGoods1 = new CartGoods();
//                    cartGoods1.setCartAid(cart.getAid());
//                    cartGoods1.setCount(styleCount);
//                    cartGoods1.setGoodsAid(Long.valueOf(param.getGoodAid()));
//                    cartGoods1.setGoodsStyleAid(goodStyleAid);
//                    cartGoodsMapper.insert(cartGoods1);
//                    CartGoods cartGoods2 = cartGoodsMapper.selectOne(new LambdaQueryWrapper<CartGoods>()
//                            .eq(CartGoods::getCartAid, cart.getAid())
//                            .eq(CartGoods::getGoodsAid, param.getGoodAid()));
//                    if (cartGoods2 == null) {
//                       cart.setGoodsNum(cart.getGoodsNum() + 1);
//                       cartMapper.updateById(cart);
//                    }
//                }
//            }else {
//                // 购物车为空，先建一条购物车数据
//                Cart cart1 = new Cart();
//                cart1.setGoodsNum(1);
//                cart1.setUserAid(userAidByToken.longValue());
//                cart1.setIsEmpty(false);
//                cartMapper.insert(cart1);
//                // 再建一条cart_goods数据
//                cartGoodsMapper.insert(new CartGoods(){{
//                    setCartAid(cart1.getAid());
//                    setGoodsStyleAid(0L);
//                    setGoodsAid(Long.valueOf(param.getGoodAid()));
//                    setCount(param.getStyleCount());
//                }});
//            }
//        }else {
//            // 该样式
//            GoodsStyle goodsStyle = goodsStyleMapper.selectById(goodsStyleAid);
//            if (cart != null) {
//
//                // 如果款式aid和商品aid都一样，说明用户加入购物车两次，需要把同样款式的数量相加
//                List<CartGoods> cartGoods = cartGoodsMapper.selectList(new LambdaQueryWrapper<CartGoods>()
//                        .eq(CartGoods::getCartAid, cart.getAid())
//                        .eq(CartGoods::getGoodsAid, goodsStyle.getGoodAid())
//                        .eq(CartGoods::getGoodsStyleAid, goodsStyleAid)
//                );
//                if (cartGoods.size() > 1) {
//                    // 合并count
//                    int totalCount = styleCount;
//                    for (CartGoods cg : cartGoods) {
//                        totalCount += cg.getCount();
//                    }
//                    CartGoods firstCartGoods = cartGoods.get(0);
//                    firstCartGoods.setCount(totalCount);
//                    // 更新第一条记录的count值
//                    cartGoodsMapper.updateById(firstCartGoods);
//                    // 删除其他重复记录
//                    for (int i = 1; i < cartGoods.size(); i++) {
//                        cartGoodsMapper.deleteById(cartGoods.get(i).getAid());
//                    }
//                    cart.setIsEmpty(false);
//                    cart.setUpdateTime(LocalDateTime.now());
//                    cartMapper.updateById(cart);
//                } else if (cartGoods.size() == 1) {
//                    // 直接将count相加之后更新就好了
//                    CartGoods cartGood = cartGoods.get(0);
//                    cartGood.setCount(cartGood.getCount() + 1);
//                    cartGoodsMapper.updateById(cartGood);
//                    cart.setIsEmpty(false);
//                    cart.setUpdateTime(LocalDateTime.now());
//                    cartMapper.updateById(cart);
//                } else {
//                    // 插入新的cartGoods数据
//                    CartGoods newCartGoods = new CartGoods();
//                    newCartGoods.setCartAid(cart.getAid());
//                    newCartGoods.setGoodsAid(goodsStyle.getGoodAid());
//                    newCartGoods.setGoodsStyleAid(goodStyleAid);
//                    newCartGoods.setCount(styleCount);
//                    cartGoodsMapper.insert(newCartGoods);
//                    cart.setGoodsNum(cart.getGoodsNum() + 1);
//                    cart.setIsEmpty(false);
//                    cart.setUpdateTime(LocalDateTime.now());
//                    cartMapper.updateById(cart);
//                }
//            }else {
//                // 说明该用户没有购物车，先建一条购物车数据
//                Cart cart1 = new Cart();
//                cart1.setUserAid(userAidByToken.longValue());
//                cart1.setIsEmpty(false);
//                cart1.setGoodsNum(1);
//                cartMapper.insert(cart1);
//                // 新建一条cart_goods数据
//                cartGoodsMapper.insert(new CartGoods() {{
//                    setCartAid(cart1.getAid());
//                    setGoodsAid(goodsStyle.getGoodAid());
//                    setGoodsStyleAid(goodStyleAid);
//                    setCount(styleCount);
//                }});
//            }
//        }
//        return ResponseWrapper.markSuccess();


        // 将前端传入的商品样式ID转换为Long类型，方便后续在数据库操作以及其他业务逻辑处理中使用，
        // 因为数据库中相关字段可能是Long类型，保持类型一致可以避免潜在的类型转换问题
        Long goodsStyleAid = param.getGoodsStyleAid().longValue();
        // 获取前端传入的商品数量，用于后续更新购物车中商品数量等操作
        Integer styleCount = param.getStyleCount();

        // 根据用户ID查询该用户对应的购物车信息，调用私有方法getCartByUserId进行查询
        Cart cart = getCartByUserId(userAidByToken);

        // 根据商品样式ID是否为0来分情况处理添加购物车的逻辑，0表示商品没有样式
        if (param.getGoodsStyleAid().equals(0)) {
            // 处理没有样式的商品添加到购物车的业务逻辑，传递相应参数，包括当前用户ID、购物车信息、商品添加参数等
            handleNoStyleGoods(userAidByToken, cart, param, goodsStyleAid, styleCount);
        } else {
            // 获取商品样式信息，通过商品样式ID从数据库中查询对应的商品样式记录，用于后续有样式商品添加到购物车的相关逻辑处理
            GoodsStyle goodsStyle = goodsStyleMapper.selectById(goodsStyleAid);
            // 处理有样式商品添加到购物车的业务逻辑，传递购物车信息、商品添加参数以及获取到的商品样式信息等
            handleStyledGoods(userAidByToken,cart, param, goodsStyle, styleCount);
        }

        // 返回表示操作成功的响应包装类，具体的成功标识等信息可根据ResponseWrapper类的实现来确定，
        // 这里表示添加购物车操作成功，返回给调用者相应的成功反馈
        return ResponseWrapper.markSuccess();

    }


    // 私有方法，根据用户ID查询该用户对应的购物车信息，通过MyBatis Plus的LambdaQueryWrapper构建查询条件，
    // 查找用户ID匹配的购物车记录，若存在则返回对应的Cart对象，若不存在则返回null
    private Cart getCartByUserId(Integer userAidByToken) {
        return cartMapper.selectOne(new LambdaQueryWrapper<Cart>()
                .eq(Cart::getUserAid, userAidByToken));
    }

    // 私有方法，处理没有样式的商品添加到购物车的情况，接收当前用户ID、购物车信息、商品添加参数等作为参数
    private void handleNoStyleGoods(Integer userAidByToken, Cart cart, AddCartParam param, Long goodsStyleAid, Integer styleCount) {
        // 如果购物车已存在（即cart不为null），说明该用户已经有购物车记录了
        if (cart!= null) {
            // 查询购物车中是否已存在该商品（无样式情况），通过构建LambdaQueryWrapper条件进行查询，
            // 根据购物车ID、商品ID以及商品样式ID（此处为0，表示无样式）来确定是否存在对应商品记录
            CartGoods cartGoods = cartGoodsMapper.selectOne(new LambdaQueryWrapper<CartGoods>()
                    .eq(CartGoods::getCartAid, cart.getAid())
                    .eq(CartGoods::getGoodsAid, param.getGoodAid())
                    .eq(CartGoods::getGoodsStyleAid, goodsStyleAid));
            // 如果已存在该商品记录（即cartGoods不为null）
            if (cartGoods!= null) {
                // 更新该商品在购物车中的数量，调用updateCartGoodsCount方法，传入当前购物车商品记录和要增加的数量
                updateCartGoodsCount(cartGoods, styleCount);
            } else {
                // 如果购物车中不存在该商品，则插入新的购物车商品记录（无样式情况），调用insertNewCartGoodsForNoStyle方法，
                // 传入购物车信息、商品添加参数等，用于构建并插入新的购物车商品记录到数据库
                insertNewCartGoodsForNoStyle(cart, param, styleCount);
                // 根据情况更新购物车中的商品数量，调用updateCartGoodsNumIfNeeded方法，传入购物车信息和商品ID，
                // 判断是否需要更新购物车的商品数量（例如新添加了一个之前不存在的商品时需要更新商品数量计数）
                updateCartGoodsNumIfNeeded(cart, param.getGoodAid());
            }
        } else {
            // 如果购物车不存在（即cart为null），则创建新的购物车以及对应的购物车商品记录（无样式情况），
            // 调用createNewCartAndCartGoodsForNoStyle方法，传入当前用户ID和商品添加参数，用于构建并插入新的购物车及购物车商品记录到数据库
            createNewCartAndCartGoodsForNoStyle(userAidByToken, param);
        }
    }

    // 私有方法，处理有样式商品添加到购物车的情况，接收购物车信息、商品添加参数以及商品样式信息等作为参数
    private void handleStyledGoods(Integer userAidByToken, Cart cart, AddCartParam param, GoodsStyle goodsStyle, Integer styleCount) {
        // 如果购物车已存在（即cart不为null），说明该用户已经有购物车记录了
        if (cart!= null) {
            // 查询购物车中是否已存在相同样式的该商品，通过构建LambdaQueryWrapper条件进行查询，
            // 根据购物车ID、商品样式对应的商品ID以及商品样式ID来查找是否存在重复的商品记录
            List<CartGoods> cartGoodsList = cartGoodsMapper.selectList(new LambdaQueryWrapper<CartGoods>()
                    .eq(CartGoods::getCartAid, cart.getAid())
                    .eq(CartGoods::getGoodsAid, goodsStyle.getGoodAid())
                    .eq(CartGoods::getGoodsStyleAid, goodsStyle.getAid()));
            // 如果存在多条相同样式的该商品记录（即cartGoodsList.size() > 1）
            if (cartGoodsList.size() > 1) {
                // 合并相同样式商品的数量，并更新记录以及删除多余的重复记录，调用mergeAndUpdateCartGoods方法，
                // 传入商品记录列表和要添加的商品数量，用于进行合并、更新及删除重复记录等操作
                mergeAndUpdateCartGoods(cartGoodsList, styleCount);
            } else if (cartGoodsList.size() == 1) {
                // 如果只存在一条相同样式的该商品记录（即cartGoodsList.size() == 1），更新该商品的数量，
                // 调用updateExistingCartGoodsCount方法，传入当前的购物车商品记录和要增加的数量，用于更新该商品在购物车中的数量
                updateExistingCartGoodsCount(cartGoodsList.get(0), styleCount);
            } else {
                // 如果购物车中不存在该样式的商品，则插入新的购物车商品记录（有样式情况），调用insertNewCartGoods方法，
                // 传入购物车信息、商品样式信息以及要添加的商品数量，用于构建并插入新的购物车商品记录到数据库，并更新购物车的商品数量（因为新添加了商品）
                insertNewCartGoods(cart, goodsStyle, styleCount);
            }
            // 更新购物车的相关信息，如是否为空、更新时间等，调用updateCartInfo方法，传入购物车信息，用于更新购物车记录到数据库
            updateCartInfo(cart);
        } else {
            // 如果购物车不存在（即cart为null），则创建新的购物车以及对应的购物车商品记录（有样式情况），
            // 调用createNewCartAndCartGoods方法，传入当前用户ID、商品样式信息以及要添加的商品数量，用于构建并插入新的购物车及购物车商品记录到数据库
            createNewCartAndCartGoods(userAidByToken, goodsStyle, styleCount);
        }
    }

        // 私有方法，更新购物车中某商品的数量，接收购物车商品记录和要增加的数量作为参数
        private void updateCartGoodsCount(CartGoods cartGoods, Integer increment) {
            // 将原数量加上传入的增量（新增数量），实现购物车中该商品数量的更新
            cartGoods.setCount(cartGoods.getCount() + increment);
            // 通过Mapper将更新后的购物车商品记录更新到数据库中，使数据库中的商品数量与业务逻辑中的数量保持一致
            cartGoodsMapper.updateById(cartGoods);
        }

        // 私有方法，插入新的购物车商品记录（针对无样式商品情况），接收购物车信息、商品添加参数等作为参数
        private void insertNewCartGoodsForNoStyle(Cart cart, AddCartParam param, Integer styleCount) {
            CartGoods newCartGoods = new CartGoods();
            // 设置购物车商品关联的购物车ID，将其与传入的购物车记录的ID进行关联，建立两者之间的对应关系
            newCartGoods.setCartAid(cart.getAid());
            // 设置商品数量，使用传入的商品数量参数来初始化新购物车商品记录中的商品数量
            newCartGoods.setCount(styleCount);
            // 设置商品ID，注意这里将前端传入的Integer类型转换为Long类型，确保与数据库中对应字段的类型一致，然后进行赋值
            newCartGoods.setGoodsAid(param.getGoodAid().longValue());
            // 设置商品样式ID为0，表示无样式，符合当前业务场景下该商品没有样式的情况
            newCartGoods.setGoodsStyleAid(0L);
            // 通过Mapper将新的购物车商品记录插入数据库，完成新记录的添加操作
            cartGoodsMapper.insert(newCartGoods);
        }

        // 私有方法，根据情况判断是否需要更新购物车中的商品数量（针对无样式商品情况），接收购物车信息和商品ID作为参数
        private void updateCartGoodsNumIfNeeded(Cart cart, Integer goodAid) {
            // 查询购物车中是否存在指定商品（通过商品ID判断），通过构建LambdaQueryWrapper条件进行查询，
            // 根据购物车ID和商品ID来查找是否存在对应的商品记录
            CartGoods cartGoods = cartGoodsMapper.selectOne(new LambdaQueryWrapper<CartGoods>()
                    .eq(CartGoods::getCartAid, cart.getAid())
                    .eq(CartGoods::getGoodsAid, goodAid));
            // 如果不存在该商品（即cartGoods为null），说明是新添加的商品，需要更新购物车的商品数量
            if (cartGoods == null) {
                cart.setGoodsNum(cart.getGoodsNum() + 1);
                cartMapper.updateById(cart);
            }
        }

        // 私有方法，创建新的购物车以及对应的购物车商品记录（针对无样式商品情况），接收当前用户ID和商品添加参数作为参数
        private void createNewCartAndCartGoodsForNoStyle(Integer userAidByToken, AddCartParam param) {
            Cart cart = new Cart();
            // 设置购物车初始商品数量为1，表示新创建的购物车中当前添加了一个商品
            cart.setGoodsNum(1);
            // 设置购物车所属用户ID，将传入的用户ID转换为Long类型后进行赋值，确保与数据库中对应字段的类型一致，建立购物车与用户的关联
            cart.setUserAid(userAidByToken.longValue());
            // 设置购物车是否为空，这里为false表示有商品，因为已经添加了商品到购物车中
            cart.setIsEmpty(false);
            // 将新的购物车记录插入数据库，完成购物车记录的创建操作
            cartMapper.insert(cart);

            CartGoods cartGoods = new CartGoods();
            // 设置购物车商品关联的购物车ID，将其与刚插入的购物车记录的ID进行关联，建立两者之间的对应关系
            cartGoods.setCartAid(cart.getAid());
            // 设置商品样式ID为0，表示无样式，符合当前业务场景下该商品没有样式的情况
            cartGoods.setGoodsStyleAid(0L);
            // 设置商品ID，注意这里将前端传入的Integer类型转换为Long类型，确保与数据库中对应字段的类型一致，然后进行赋值
            cartGoods.setGoodsAid(param.getGoodAid().longValue());
            // 设置商品数量，使用传入的商品数量参数来初始化新购物车商品记录中的商品数量
            cartGoods.setCount(param.getStyleCount());
            // 将新的购物车商品记录插入数据库，完成新购物车商品记录的添加操作
            cartGoodsMapper.insert(cartGoods);
        }

        // 私有方法，合并相同样式商品的数量，更新第一条记录并删除其他重复记录，接收商品记录列表和要添加的商品数量作为参数
        private void mergeAndUpdateCartGoods(List<CartGoods> cartGoodsList, Integer styleCount) {
            int totalCount = styleCount;
            // 累加所有相同样式商品的数量，先将传入的要添加的商品数量作为初始值，然后遍历列表累加已有商品的数量
            for (CartGoods cg : cartGoodsList) {
                totalCount += cg.getCount();
            }
            // 获取第一条记录，用于更新合并后的数量，因为在业务逻辑中选择保留第一条记录，并更新其数量为合并后的总数
            CartGoods firstCartGoods = cartGoodsList.get(0);
            firstCartGoods.setCount(totalCount);
            // 通过Mapper更新第一条记录的商品数量到数据库，使数据库中的商品数量反映合并后的结果
            cartGoodsMapper.updateById(firstCartGoods);

            // 删除其他重复记录（除第一条外），通过遍历列表（从索引1开始，因为索引0的记录已更新并保留），根据记录的ID删除多余的重复记录
            for (int i = 1; i < cartGoodsList.size(); i++) {
                cartGoodsMapper.deleteById(cartGoodsList.get(i).getAid());
            }
        }

        // 私有方法，更新购物车中已存在的某商品（有样式情况）的数量，接收购物车商品记录和要增加的数量作为参数
        private void updateExistingCartGoodsCount(CartGoods cartGoods, Integer styleCount) {
            // 将原数量加上传入的增量（新增数量），实现购物车中该商品数量的更新
            cartGoods.setCount(cartGoods.getCount() + styleCount);
            // 通过Mapper将更新后的购物车商品记录更新到数据库中，使数据库中的商品数量与业务逻辑中的数量保持一致
            cartGoodsMapper.updateById(cartGoods);
        }

        // 私有方法，插入新的购物车商品记录（针对有样式商品情况），接收购物车信息、商品样式信息以及要添加的商品数量作为参数
        private void insertNewCartGoods(Cart cart, GoodsStyle goodsStyle, Integer styleCount) {
            CartGoods newCartGoods = new CartGoods();
            // 设置购物车商品关联的购物车ID，将其与传入的购物车记录的ID进行关联，建立两者之间的对应关系
            newCartGoods.setCartAid(cart.getAid());
            // 设置商品ID，使用商品样式对应的商品ID进行赋值，确保关联正确的商品
            newCartGoods.setGoodsAid(goodsStyle.getGoodAid());
            // 设置商品样式ID，使用传入的商品样式记录中的样式ID进行赋值，确保关联正确的商品样式
            newCartGoods.setGoodsStyleAid(goodsStyle.getAid());
            // 设置商品数量，使用传入的商品数量参数来初始化新购物车商品记录中的商品数量
            newCartGoods.setCount(styleCount);
            // 通过Mapper将新的购物车商品记录插入数据库，完成新记录的添加操作，并更新购物车的商品数量（因为新添加了商品）
            cartGoodsMapper.insert(newCartGoods);
            cart.setGoodsNum(cart.getGoodsNum() + 1);
        }

    // 私有方法，更新购物车的相关信息，如是否为空、更新时间等，接收购物车信息作为参数
    private void updateCartInfo(Cart cart) {
        // 设置购物车是否为空，这里为false表示有商品，因为已经添加或操作了商品，
        cart.setIsEmpty(false);
        cart.setUpdateTime(LocalDateTime.now());
        cartMapper.updateById(cart);
    }

    private void createNewCartAndCartGoods(Integer userAidByToken, GoodsStyle goodsStyle, Integer styleCount) {
        Cart cart = new Cart();
        cart.setUserAid(userAidByToken.longValue());
        cart.setIsEmpty(false);
        cart.setGoodsNum(1);
        cartMapper.insert(cart);

        CartGoods cartGoods = new CartGoods();
        cartGoods.setCartAid(cart.getAid());
        cartGoods.setGoodsAid(goodsStyle.getGoodAid());
        cartGoods.setGoodsStyleAid(goodsStyle.getAid());
        cartGoods.setCount(styleCount);
        cartGoodsMapper.insert(cartGoods);
    }


    @Override
    public ResponseWrapper getCurrentStyleAid(Integer goodAid, String styleName) {

        // 要判断商品样式是否为空：因为有些商品不需要样式
        if(styleName.isEmpty()){
            return ResponseWrapper.markSuccess(0);
        }
        List<GoodsStyle> goodsStyles = goodsStyleMapper.selectList(new LambdaQueryWrapper<GoodsStyle>()
                .eq(GoodsStyle::getGoodAid, goodAid)
                .eq(GoodsStyle::getStyleValue, styleName)
        );
        if (!goodsStyles.isEmpty()) {
            return ResponseWrapper.markSuccess(goodsStyles.get(0).getAid());
        }
        return ResponseWrapper.markError();
    }

    @Override
    public ResponseWrapper getSearchResults(String searchKey,Integer selectedMenuAid) {

        List<Goods> goods = new ArrayList<Goods>();

        if (selectedMenuAid.equals(1)){
            // 全部
            goods = goodsMapper.selectList(new LambdaQueryWrapper<Goods>()
                    .like(Goods::getGoodsName, searchKey)
                    .orderByDesc(Goods::getUpdateTime)
            );
        }else if (selectedMenuAid.equals(2)){
            // 销量
            goods = goodsMapper.selectList(new LambdaQueryWrapper<Goods>()
                    .like(Goods::getGoodsName, searchKey)
                    .orderByDesc(Goods::getPurchaseQuantity)
                    .orderByDesc(Goods::getUpdateTime)
            );
        }else {
            // 按价格排序
            goods = goodsMapper.selectList(new LambdaQueryWrapper<Goods>()
                    .like(Goods::getGoodsName, searchKey)
                    .orderByDesc(Goods::getGoodsPrice)
                    .orderByDesc(Goods::getUpdateTime)
            );
        }
        ArrayList<HashMap<String, Object>> hashMaps = new ArrayList<>();
        for (Goods good : goods) {
            HashMap<String, Object> map = new HashMap<>();
            map.put("goodAid",good.getAid());
            map.put("goodImg",good.getGoodsMainImage());
            map.put("goodName",good.getGoodsName().length() > 7 ? good.getGoodsName().substring(0,7) + "..." : good.getGoodsName());
            map.put("goodPrice", "￥" + good.getGoodsPrice());
            hashMaps.add(map);
        }
        return ResponseWrapper.markSuccess(hashMaps);
    }

    @Override
    public ResponseWrapper getsearchHistAndGuessSearchList(Integer userAidByToken) {

        // 获取搜索历史
        List<SearchHistory> searchHistories = searchHistoryMapper.selectList(new LambdaQueryWrapper<SearchHistory>()
                .eq(SearchHistory::getUserAid, userAidByToken)
                .orderByDesc(SearchHistory::getCreateTime)
                .eq(SearchHistory::getSearchType, "商品")
        );

        // 获取猜你想搜
        List<SearchHistory> guessSearchHis = searchHistoryMapper.selectList(new LambdaQueryWrapper<SearchHistory>()
                .eq(SearchHistory::getUserAid, userAidByToken)
                .eq(SearchHistory::getSearchType, "商品")
                .orderByDesc(SearchHistory::getCount)
        );

        HashMap<String, Object> result = new HashMap<>();
        result.put("searchHistories",searchHistories);
        result.put("guessSearchHis",guessSearchHis);
        return ResponseWrapper.markSuccess(result);

    }

    @Override
    public ResponseWrapper deleteSearchByAid(Integer userAidByToken, Integer aid) {

        SearchHistory searchHistory = searchHistoryMapper.selectOne(new LambdaQueryWrapper<SearchHistory>()
                .eq(SearchHistory::getUserAid, userAidByToken)
                .eq(SearchHistory::getAid, aid)
        );
        if (searchHistory != null){
            return searchHistoryMapper.deleteById(aid) > 0 ? ResponseWrapper.markSuccess() : ResponseWrapper.markError();
        }
        return ResponseWrapper.markError();
    }

    @Override
    public ResponseWrapper addSearchHistory(Integer userAidByToken, AddSearchGoodsHistoryParam param) {

        List<SearchHistory> searchHistories = searchHistoryMapper.selectList(new LambdaQueryWrapper<SearchHistory>()
                .eq(SearchHistory::getUserAid, userAidByToken)
                .eq(SearchHistory::getName, param.getSearchValue())
        );
        if (searchHistories.size() > 0){
            // 有这个搜索历史了，不添加，增加一个搜索数量就好了
            SearchHistory searchHistory = searchHistories.get(0);
            searchHistory.setCount(searchHistory.getCount() + 1);
            searchHistoryMapper.updateById(searchHistory);
        }else {
            // 添加一个搜索历史
            SearchHistory searchHistory = new SearchHistory();
            // 查询现有aid，找出最小未使用的aid
            List<Object> allAids = searchHistoryMapper.selectObjs(new LambdaQueryWrapper<SearchHistory>()
                    .select(SearchHistory::getAid)
                    .orderByAsc(SearchHistory::getAid)
                    .groupBy(SearchHistory::getAid)
            );

            if (allAids.size() > 0){
                int targetAid = 1;
                if (!allAids.isEmpty()) {
                    for (int i = 0; i < allAids.size(); i++) {
                        int currentAid = Integer.parseInt(allAids.get(i).toString());
                        if (currentAid == targetAid) {
                            targetAid++;
                        } else {
                            break;
                        }
                    }
                }
                System.out.println("这儿呢");
                System.out.println(targetAid);
                searchHistory.setAid(Long.valueOf(targetAid));
            }else {
                searchHistory.setAid(1l);
            }
            searchHistory.setName(param.getSearchValue());
            searchHistory.setUserAid(Long.valueOf(userAidByToken));
            searchHistory.setCount(1);
            searchHistory.setSearchType("商品");
            // 根据关键字查询，商品是否是new和hot
            List<Goods> goods = goodsMapper.selectList(new LambdaQueryWrapper<Goods>()
                    .eq(Goods::getGoodsName, param.getSearchValue())
                    .eq(Goods::getIsNew,true)
                    .or()
                    .eq(Goods::getGoodsName, param.getSearchValue())
                    .eq(Goods::getIsHot,true)
            );
            if (goods.size() > 0){
                searchHistory.setHaveLabel(true);
                Goods goods1 = goods.get(0);
                if (goods1.getIsNew()){
                    searchHistory.setLabelName("new");
                }else if(goods1.getIsHot()){
                    searchHistory.setLabelName("hot");
                }else {
                    searchHistory.setLabelName(null);
                }
            }else {
                searchHistory.setHaveLabel(false);
                searchHistory.setLabelName(null);
            }
            searchHistoryMapper.insert(searchHistory);
        }
        return ResponseWrapper.markSuccess();
    }

    @Override
    public ResponseWrapper deleteAllSearchHistory(Integer userAidByToken) {
        int delete = searchHistoryMapper.delete(new LambdaQueryWrapper<SearchHistory>()
                .eq(SearchHistory::getUserAid, userAidByToken));
        if (delete > 0){
            return ResponseWrapper.markSuccess();
        }else {
            return ResponseWrapper.markError();
        }
    }
}
